{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "71e6d8fe-84c4-47d7-8fd7-f6a66fed72e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import os\n",
    "import json\n",
    "import operator\n",
    "import pandas as pd\n",
    "from io import StringIO\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# settings\n",
    "BotHash = \"BEEB1E1549DDD01226DC2FC912ABAE49\"\n",
    "BotName = \"PokerShark2\"\n",
    "SB = 10\n",
    "\n",
    "# players\n",
    "Players = ['PokerShark1']\n",
    "\n",
    "# helper functions\n",
    "def prettyPrint(*arguments):\n",
    "    out = ''\n",
    "    for arg in arguments:\n",
    "        space = (30-len(arg)) * \" \"\n",
    "        out += arg + space\n",
    "    print(out)\n",
    "\n",
    "# gets an array of paths to player games\n",
    "def getGamesPath(playerName):\n",
    "    return [os.path.join(playerName,f) for f in os.listdir(playerName) if not f.startswith('.')]\n",
    "\n",
    "# Load game as json object.\n",
    "def loadGame(path):\n",
    "    with open(path) as f:\n",
    "        g = json.load(f)\n",
    "        # Throw if game not logged by the current version of the bot\n",
    "        if g[\"BotHash\"] != BotHash:\n",
    "            #raise Exception(\"BotHash does not match: \" + g[\"BotHash\"])\n",
    "            pass\n",
    "        return g\n",
    "\n",
    "# game statistics\n",
    "def getGamesCount(playerName):\n",
    "    # returns number of games played against the given player.\n",
    "    return len(getGamesPath(playerName))\n",
    "\n",
    "def getGameResultForPlayer(game, playerName):\n",
    "    # returns game result for given player.\n",
    "    results = game[\"Results\"]\n",
    "    maxStack = 0\n",
    "    hasMax = []\n",
    "    # find max stack\n",
    "    for result in results:\n",
    "        if maxStack < result[\"Stack\"]:\n",
    "            maxStack = result[\"Stack\"]\n",
    "            hasMax= [result[\"Player\"][\"Name\"]]\n",
    "        elif maxStack == result[\"Stack\"]:\n",
    "            hasMax.append(result[\"Player\"][\"Name\"])\n",
    "    # find player result\n",
    "    if playerName in hasMax:\n",
    "        if len(hasMax) > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonGamesCount(playerName):\n",
    "    # returns number of games won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'W':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewGamesCount(playerName):\n",
    "    # return number of games drew against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'D':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getLostGamesCount(playerName):\n",
    "    # return number of games lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'L':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getEndStack(playerName):\n",
    "    # return sum of the stack after the games.\n",
    "    s = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for result in game[\"Results\"]:\n",
    "            if result[\"Player\"][\"Name\"] == BotName:\n",
    "                s += result[\"Stack\"]\n",
    "    return s\n",
    "            \n",
    "# round statistics\n",
    "def getRoundsCount(playerName):\n",
    "    # returns number of rounds played against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        count += len(game[\"Rounds\"])\n",
    "    return count\n",
    "\n",
    "def GetRoundResultForPlayer(r, playerName):\n",
    "    results = r[\"Winner\"]\n",
    "    winners = len(results)\n",
    "    won = False\n",
    "    for result in results:\n",
    "        if playerName == result[\"Name\"]:\n",
    "            won = True\n",
    "            break\n",
    "    if won:\n",
    "        if winners > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonRoundsCount(playerName):\n",
    "    # returns number of rounds won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'W':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewRoundsCount(playerName):\n",
    "    # return number of games rounds against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'D':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getLostRoundsCount(playerName):\n",
    "    # return number of rounds lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'L':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def endedBeforeShowdown(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\":\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def botFolded(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\" and action[\"PlayerName\"] == BotName:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def getPaid(r,playerName):\n",
    "    # returns amount paid by player\n",
    "    amount = 0\n",
    "    # blinds\n",
    "    sbp = r['SmallBlindPosition']\n",
    "    for p in range(len(r['Players'])):\n",
    "        if r['Players'][p]['Name'] == playerName:\n",
    "            if p == sbp:\n",
    "                amount += SB\n",
    "            else:\n",
    "                amount += SB + SB\n",
    "    # calls and raises\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] != \"Fold\" and action[\"PlayerName\"] == playerName:\n",
    "            amount += action[\"Amount\"]\n",
    "    return amount\n",
    "\n",
    "# winning statistics\n",
    "def getNonShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if endedBeforeShowdown(r):\n",
    "                if botFolded(r):\n",
    "                    line -= getPaid(r,BotName)\n",
    "                else:\n",
    "                    line += getPaid(r,playerName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if not endedBeforeShowdown(r):\n",
    "                # if bot won\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                    line += getPaid(r,playerName)\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                    line -= getPaid(r,BotName)\n",
    "                \n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getStackLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                line += getPaid(r,playerName)\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                line -= getPaid(r,BotName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def plotWinnings(playerName):\n",
    "    # NonShowdownWinningsLine\n",
    "    x,y = getNonShowdownWinningsLine(playerName)\n",
    "    fig, ax = plt.subplots()\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Non-showdown winnings', c='r')\n",
    "    # ShowdownWinningsLine\n",
    "    x,y = getShowdownWinningsLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Showdown winnings', c='b')\n",
    "    # Stack\n",
    "    x,y = getStackLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Winnings', c='g')\n",
    "    # show plot\n",
    "    y_max = np.abs(ax.get_ylim()).max()\n",
    "    ax.set_ylim(ymin=-y_max, ymax=y_max)\n",
    "    ax.set_xlim(left=0)\n",
    "    plt.legend()\n",
    "    plt.grid(linestyle = '--', linewidth = 0.5)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# Print Results\n",
    "def PrintResult():\n",
    "    for player in Players:\n",
    "        prettyPrint(\"Results against:\", player)\n",
    "        # game statistics\n",
    "        n = getGamesCount(player)\n",
    "        w = getWonGamesCount(player)\n",
    "        d = getDrewGamesCount(player)\n",
    "        l = getLostGamesCount(player)\n",
    "        prettyPrint(\"number of games:\",str(n))\n",
    "        prettyPrint(\"number of games won:\", str(w) , \"{:.1f}\".format(w*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games drew:\", str(d), \"{:.1f}\".format(d*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games lost:\", str(l), \"{:.1f}\".format(l*100/n) + \"%\")\n",
    "        # round statistics\n",
    "        rn = getRoundsCount(player)\n",
    "        rw = getWonRoundsCount(player)\n",
    "        rd = getDrewRoundsCount(player)\n",
    "        rl = getLostRoundsCount(player)\n",
    "        prettyPrint(\"number of rounds:\",str(rn))\n",
    "        prettyPrint(\"number of rounds won:\", str(rw) , \"{:.1f}\".format(rw*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds drew:\", str(rd), \"{:.1f}\".format(rd*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds lost:\", str(rl), \"{:.1f}\".format(rl*100/rn) + \"%\")\n",
    "        # winnings\n",
    "        prettyPrint(\"starting stack:\", str(1000 * n))\n",
    "        prettyPrint(\"end stack:\", str(getEndStack(player)))\n",
    "        prettyPrint(\"win/loss:\", str(getEndStack(player) - (1000 * n)  ))\n",
    "        prettyPrint(\"WPH:\", str((getEndStack(player) - (1000 * n)) / (rn*10)))\n",
    "        plotWinnings(player)\n",
    "        # end\n",
    "        print('-------------------------------------------------------------')\n",
    "        \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f45a61bb-8373-4bd1-8fd6-b85a124517bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "neutral player:\n",
      "Results against:              PokerShark1                   \n",
      "number of games:              100                           \n",
      "number of games won:          57                            57.0%                         \n",
      "number of games drew:         3                             3.0%                          \n",
      "number of games lost:         40                            40.0%                         \n",
      "number of rounds:             10000                         \n",
      "number of rounds won:         5039                          50.4%                         \n",
      "number of rounds drew:        3                             0.0%                          \n",
      "number of rounds lost:        4958                          49.6%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    101930.0                      \n",
      "win/loss:                     1930.0                        \n",
      "WPH:                          0.0193                        \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "risk-averse player:\n",
      "Results against:              PokerShark2                   \n",
      "number of games:              100                           \n",
      "number of games won:          40                            40.0%                         \n",
      "number of games drew:         3                             3.0%                          \n",
      "number of games lost:         57                            57.0%                         \n",
      "number of rounds:             10000                         \n",
      "number of rounds won:         4958                          49.6%                         \n",
      "number of rounds drew:        3                             0.0%                          \n",
      "number of rounds lost:        5039                          50.4%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    98070.0                       \n",
      "win/loss:                     -1930.0                       \n",
      "WPH:                          -0.0193                       \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "neutral = \"PokerShark2\"\n",
    "averse = \"PokerShark1\"\n",
    "\n",
    "# print neutral stats\n",
    "print(\"neutral player:\")\n",
    "BotName = neutral\n",
    "os.rename(\"games\", averse)\n",
    "Players = [averse]\n",
    "PrintResult()\n",
    "\n",
    "# print Risk averse stats\n",
    "print(\"risk-averse player:\")\n",
    "BotName = averse\n",
    "os.rename(averse, neutral)\n",
    "Players = [neutral]\n",
    "PrintResult()\n",
    "os.rename(neutral, \"games\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb3052c-f407-4cc7-a654-f4b4264b1b01",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
